package io.github.echarts.coordinator;

import io.github.echarts.model.SeriesModel;
import io.github.echarts.model.series.BarSeriesModel;
import io.github.echarts.model.series.SeriesDataManager;
import io.github.echarts.render.GraphicsRenderer;
import io.github.echarts.model.coordinate.DataRange;
import io.github.echarts.model.geometry.Rectangle;

import java.util.ArrayList;
import java.util.List;

/**
 * 系列数据渲染协调器
 * 负责协调各类系列数据的渲染过程
 */
public class SeriesRenderingCoordinator {
    
    /** 系列数据管理器 */
    private SeriesDataManager seriesDataManager;
    
    /** 渲染上下文 */
    private RenderContext renderContext;
    
    /**
     * 构造函数
     */
    public SeriesRenderingCoordinator() {
    }
    
    /**
     * 构造函数
     * 
     * @param seriesDataManager 系列数据管理器
     */
    public SeriesRenderingCoordinator(SeriesDataManager seriesDataManager) {
        this.seriesDataManager = seriesDataManager;
    }
    
    /**
     * 设置渲染上下文
     * 
     * @param renderContext 渲染上下文
     */
    public void setRenderContext(RenderContext renderContext) {
        this.renderContext = renderContext;
    }
    
    /**
     * 设置系列数据管理器
     * 
     * @param seriesDataManager 系列数据管理器
     */
    public void setSeriesDataManager(SeriesDataManager seriesDataManager) {
        this.seriesDataManager = seriesDataManager;
    }
    
    /**
     * 渲染所有系列数据
     * 
     * @param renderer 图形渲染器
     */
    public void renderSeries(GraphicsRenderer renderer) {
        if (seriesDataManager == null) {
            return;
        }
        
        // 设置当前层为数据层
        renderer.setCurrentLayer("series");
        
        // 获取所有系列模型
        List<SeriesModel> seriesList = seriesDataManager.getSeriesModels();
        
        // 遍历渲染所有系列
        for (SeriesModel series : seriesList) {
            renderSingleSeries(series, renderer);
        }
    }
    
    /**
     * 渲染单个系列数据
     * 
     * @param series 系列模型
     * @param renderer 图形渲染器
     */
    private void renderSingleSeries(SeriesModel series, GraphicsRenderer renderer) {
        // 根据系列类型选择合适的渲染方法
        if (series instanceof BarSeriesModel) {
            renderBarSeries((BarSeriesModel) series, renderer);
        }
        // 其他类型的图表渲染可以在这里添加
    }
    
    /**
     * 渲染柱状图系列
     * 
     * @param barSeries 柱状图系列模型
     * @param renderer 图形渲染器
     */
    private void renderBarSeries(BarSeriesModel barSeries, GraphicsRenderer renderer) {
        // 获取系列所属的坐标系信息
        String coordinateSystemId = barSeries.getCoordinateSystemId();
        RenderContext.CoordinateSystemInfo csInfo = renderContext.getCoordinateSystemInfo(coordinateSystemId);
        
        if (csInfo == null) {
            return;
        }
        
        // 获取坐标系区域
        Rectangle area = csInfo.getArea();
        int x = (int) area.getX();
        int y = (int) area.getY();
        int width = (int) area.getWidth();
        int height = (int) area.getHeight();
        
        // 获取数据范围 - 使用SeriesDataManager中的范围
        DataRange dataRange = seriesDataManager.getDataRange(coordinateSystemId);
        if (dataRange == null) {
            dataRange = new DataRange(0, 100); // 默认值
        }
        
        // 获取数据
        List<Object> rawData = barSeries.getData();
        if (rawData == null || rawData.isEmpty()) {
            return;
        }
        
        // 柱状图的柱子宽度
        int barWidth = 20;
        
        // 计算每个数据点之间的间距
        double xStep = width / (double) (rawData.size() + 1);
        
        // 绘制每个数据点对应的柱子
        for (int i = 0; i < rawData.size(); i++) {
            Object rawValue = rawData.get(i);
            double doubleValue = 0;
            
            // 提取数值
            if (rawValue instanceof Number) {
                doubleValue = ((Number) rawValue).doubleValue();
            } else {
                try {
                    doubleValue = Double.parseDouble(rawValue.toString());
                } catch (Exception e) {
                    // 忽略无法解析的值
                }
            }
            
            // 映射数据到坐标系中的位置
            double xPos = x + (i + 1) * xStep - barWidth / 2.0;
            
            // 计算高度（注意：在逻辑坐标系中，y轴向上，所以高度要从y开始向上绘制）
            // 首先将数据值归一化到0-1范围
            double normalizedValue = (doubleValue - dataRange.getMin()) / (dataRange.getMax() - dataRange.getMin());
            // 然后映射到坐标系高度
            double barHeight = normalizedValue * height;
            
            // 默认颜色
            String color = "#5470C6";
            
            // 绘制柱子（注意：在逻辑坐标系中，矩形的起点是左下角）
            renderer.drawRect(
                (int) xPos,       // 左下角x坐标
                y,                // 左下角y坐标
                barWidth,         // 宽度
                (int) barHeight,  // 高度
                true,             // 填充
                color,            // 填充颜色
                "#000000"         // 边框颜色
            );
        }
    }
} 